package array;

import java.util.Arrays;
import java.util.Set;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 苏李涛
 * Date: 2024-07-06
 * Time: 19:51
 */
public class Generic<E>/*泛型类*/ {
    public Object[] array2 = new Object[30];



    public E GetArray (int pos) {
        return (E)array2[pos]; //这里注意，把类型强制转换为->泛型
    }

    public void SetArray(int pos, E val) {
        this.array2[pos] = val;
    }


    public static void main1(String[] args) {

        Generic<Integer/*放置想要指定的了类型*/> generic = new Generic();
        generic.SetArray(0,2);
        generic.SetArray(1,3);

        Integer a = generic.GetArray(0);//自动进行类型检查
        System.out.println(a);


        /**
         * 为了兼容老版本的裸类型，不推荐使用
         */
        Generic /*这里不写类型*/generic1 = new Generic();
        generic1.SetArray(0,2);
        generic1.SetArray(1,3);

        Integer a1 = (Integer)/*这里转型*/ generic1.GetArray(0);//自动进行类型检查
        System.out.println(a1);

    }



    //泛型的上界
    static class Alg<E extends Comparable<E>> {
        public E Find_Max(E[] array) {
            E max =  array[0];
            for (int i = 0; i < array.length; i++) {
                if (max.compareTo(array[i]) < 0) /*这里不可以通过引用比较，要使用接口里的方法比较*/ {
                    max = array[i];
                }
            }
            return max;
        }
    }

    public static void main2(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = new Integer[]{1,2,3,4,5,6,7};
       int ret = alg.Find_Max(array);
        System.out.println(ret);
    }






    //泛型方法
    public <E extends Comparable<E>> E Find_Max1(E[] array) {
        E max =  array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) /*这里不可以通过引用比较，要使用接口里的方法比较*/ {
                max = array[i];
            }
        }
        return max;
    }

    public static void main3(String[] args) {
        Generic generic = new Generic();
        Integer[] array = new Integer[]{1,2,3,4,5,6,7};
        int ret =(Integer) generic.Find_Max1(array);
        System.out.println(ret);
    }




    //静态泛型方法：可以不用每次，实例化对象去调用方法，因为静态行为，不依赖对象，可以直接用类名调用
    public static <E extends Comparable<E>> E Find_Max2(E[] array2) {

        E max =  array2[0];
        for (int i = 0; i < array2.length; i++) {
            if (max.compareTo(array2[i]) < 0) /*这里不可以通过引用比较，要使用接口里的方法比较*/ {
                max = array2[i];
            }
        }
        return max;
    }


    public static void main(String[] args) {
        Integer[] array = new Integer[]{1,2,3,4,5,6,7};
        Integer ret = Generic.Find_Max2(array); //直接用类名调用
        System.out.println(ret);
    }
}


